export function generateRoutes(data) {
  var tree = handleTree(data, 'id', 'parentid', 'children')
  function createRoutes(nodes) {
    return nodes.map(node => {
      let route = {
        path: node.menucode,
        meta: { title: node.menuname },
        hidden: node.isneed === 0,
        children: node.children ? createRoutes(node.children) : [],
        order: node.orderno // Add order to the node
      }
      return route
    })
  }
  var routes = createRoutes(tree)
  routes.sort((a, b) => a.order - b.order)
  if (routes[0].path == '/home') {
    return routes[0].children
  } else {
    return routes
  }
}

export function handleTree(data, id, parentId, children) {
  let config = {
    id: id || 'id',
    parentId: parentId || 'parentId',
    childrenList: children || 'children'
  }

  let childrenListMap = {}
  let nodeIds = {}
  let tree = []

  // 构建childrenListMap和nodeIds
  for (let d of data) {
    let pid = d[config.parentId]
    if (childrenListMap[pid] == null) {
      childrenListMap[pid] = []
    }
    nodeIds[d[config.id]] = d
    childrenListMap[pid].push(d)
  }

  // 排序
  for (let pid in childrenListMap) {
    childrenListMap[pid].sort((a, b) => {
      if (a.orderno !== undefined && b.orderno !== undefined) {
        return a.orderno - b.orderno
      }
      return 0
    })
  }

  // 构建树
  for (let d of data) {
    let pid = d[config.parentId]
    if (nodeIds[pid] == null) {
      tree.push(d)
    }
  }

  // 使用循环代替递归
  for (let t of tree) {
    let stack = [t]
    while (stack.length > 0) {
      let current = stack.pop()
      let children = childrenListMap[current[config.id]] || []
      current[config.childrenList] = children
      for (let child of children) {
        stack.push(child)
      }
    }
  }

  return tree
}
// 防抖函数
export function debounce(func, wait, immediate) {
  let timeout // 定义一个计时器变量，用于延迟执行函数
  return function (...args) {
    // 返回一个包装后的函数
    const context = this // 保存函数执行上下文对象
    const later = function () {
      // 定义延迟执行的函数
      timeout = null // 清空计时器变量
      if (!immediate) func.apply(context, args) // 若非立即执行，则调用待防抖函数
    }
    const callNow = immediate && !timeout // 是否立即调用函数的条件
    clearTimeout(timeout) // 清空计时器
    timeout = setTimeout(later, wait) // 创建新的计时器，延迟执行函数
    if (callNow) func.apply(context, args) // 如果满足立即调用条件，则立即执行函数
  }
}

// 节流函数
export function throttle(func, wait) {
  let timeout // 定义一个计时器变量，用于限制函数调用频率
  return function (...args) {
    // 返回一个包装后的函数
    const context = this // 保存函数执行上下文对象
    if (!timeout) {
      // 如果计时器不存在
      func.apply(context, args) // 执行函数
      timeout = setTimeout(() => {
        timeout = null // 清空计时器变量
      }, wait) // 创建计时器，在指定时间后重置计时器变量
    }
  }
}
